﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Management;
using System.Text;

namespace HenrryTools.Common.Computer
{
    //https://docs.microsoft.com/en-us/windows/win32/cimwin32prov/win32-physicalmemory
    //API和Keys枚举

    /// <summary>
    /// windows api 名称
    /// </summary>
    public enum WindowsAPIType
    {
        /// <summary>
        /// 内存
        /// </summary>
        Win32_PhysicalMemory,
        /// <summary>
        /// cpu
        /// </summary>
        Win32_Processor,
        /// <summary>
        /// 硬盘
        /// </summary>
        win32_DiskDrive,
        /// <summary>
        /// 电脑型号
        /// </summary>
        Win32_ComputerSystemProduct,
        /// <summary>
        /// 分辨率
        /// </summary>
        Win32_DesktopMonitor,
        /// <summary>
        /// 显卡
        /// </summary>
        Win32_VideoController,
        /// <summary>
        /// 操作系统
        /// </summary>
        Win32_OperatingSystem

    }
    public enum WindowsAPIKeys
    {
        /// <summary>
        /// CPU名称
        /// </summary>
        Name,
        /// <summary>
        /// 显卡芯片
        /// </summary>
        VideoProcessor,
        /// <summary>
        /// 显存大小
        /// </summary>
        AdapterRAM,
        /// <summary>
        /// 分辨率宽
        /// </summary>
        ScreenWidth,
        /// <summary>
        /// 分辨率高
        /// </summary>
        ScreenHeight,
        /// <summary>
        /// 电脑型号
        /// </summary>
        Version,
        /// <summary>
        /// 硬盘容量
        /// </summary>
        Size,
        /// <summary>
        /// 内存容量
        /// </summary>
        Capacity,
        /// <summary>
        /// cpu核心数
        /// </summary>
        NumberOfCores
    }
    /// <summary>
    /// 内存信息 （显示模型）
    /// </summary>
    public class MemoryView
    {
        /// <summary>
        /// 计算机 总内存大小
        /// </summary>
        public string TotalSize { get; set; }
        /// <summary>
        /// 内存条数
        /// </summary>
        public byte MemoryCount { get; set; }

        public List<MemoryCardInfo> MemoryCardList { get; set; }
    }
    /// <summary>
    /// 内存卡 信息
    /// </summary>
    public class MemoryCardInfo
    {
        /// <summary>
        /// 制造商
        /// </summary>
        public string Manufacturer { get; set; }
        /// <summary>
        /// 容量
        /// </summary>
        public string Capacity { get; set; }
        /// <summary>
        /// 配置电压 单位毫伏
        /// </summary>
        public int Voltage { get; set; }

        /// <summary>
        /// 出厂编号（零件编号）
        /// </summary>
        public string PartNumber { get; set; }
        /// <summary>
        /// 序列号
        /// </summary>
        public string SerialNumber { get; set; }
        /// <summary>
        /// 数据宽度（位宽 每次传输位数 bit）
        /// </summary>
        public int DataWidth { get; set; }
        /// <summary>
        /// 内存时钟频率 (单位 MHz)
        /// </summary>
        public int ConfiguredClockSpeed { get; set; }
    }

    /// <summary>
    /// 物理磁盘
    /// </summary>
    public class PhisicalDisk
    {
        /// <summary>
        /// name
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 制造商
        /// </summary>
        public string Manufacturer { get; set; }
        /// <summary>
        /// 磁盘型号
        /// </summary>
        public string Model { get; set; }
        /// <summary>
        /// 序列号
        /// </summary>
        public string SerialNumber { get; set; }
        /// <summary>
        /// 磁盘大小
        /// </summary>
        public UInt64 Size { get; set; }
        /// <summary>
        /// 接口类型
        /// </summary>
        public string InterfaceType { get; set; }

    }
    /// <summary>
    /// 逻辑磁盘
    /// </summary>
    public class LogicalDisk
    {
        /// <summary>
        /// 盘符
        /// </summary>
        public string DeviceID { get; set; }
        /// <summary>
        /// 卷标名
        /// </summary>
        public string VolumeName { get; set; }
        /// <summary>
        /// 容量（总空间 单位字节）
        /// </summary>
        public string Size { get; set; }
        /// <summary>
        /// 可用空间 （单位字节）
        /// </summary>
        public UInt64 FreeSpace { get; set; }
        /// <summary>
        /// 使用空间（占用空间）
        /// </summary>
        public string UseSpace { get; set; }
        /// <summary>
        /// 文件系统类型 （FAT，NTFS，FAT32等）
        /// </summary>
        public string FileSystem { get; set; }

    }
    /// <summary>
    /// 磁盘信息 （显示模型）
    /// </summary>
    public class DiskView
    {
        public PhisicalDisk PhisicalDiskInfo { get; set; }
        public List<LogicalDisk> LogicalDiskListInfo { get; set; }
    }

    /// <summary>
    /// /显卡信息
    /// </summary>
    public class GraphicsCard
    {
        /// <summary>
        /// 姓名或数字 - (模拟转换器（DAC）芯片的标识符)
        /// </summary>
        public string AdapterDACType { get; set; }
        /// <summary>
        /// 显存大小
        /// </summary>
        public UInt32 AdapterRAM { get; set; }
        /// <summary>
        /// 显卡简短描述
        /// </summary>
        public string Caption { get; set; }
        /// <summary>
        /// 显卡描述
        /// </summary>
        public string Description { get; set; }
        /// <summary>
        /// 当前已安装的视频驱动程序的最后修改日期和时间
        /// </summary>
        public string DriverDate { get; set; }
        /// <summary>
        /// 视频驱动程序的版本号
        /// </summary>
        public string DriverVersion { get; set; }
        /// <summary>
        /// 标签由该对象是已知的。当子类，该属性可以被覆盖是一个关键属性。
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 显卡当前状态
        /// </summary>
        public string Status { get; set; }
        /// <summary>
        /// 当前的分辨率，颜色和视频控制器的扫描模式设置
        /// </summary>
        public string VideoModeDescription { get; set; }
        /// <summary>
        /// 无格式的字符串描述视频处理器
        /// </summary>
        public string VideoProcessor { get; set; }
        /// <summary>
        /// 最大刷新频率
        /// </summary>
        public UInt32 MaxRefreshRate { get; set; }
        /// <summary>
        /// 最小刷新频率
        /// </summary>
        public UInt32 MinRefreshRate { get; set; }
        /// <summary>
        /// 比特数以显示每个像素
        /// </summary>
        public UInt32 CurrentBitsPerPixel { get; set; }
    }
    /// <summary>
    /// 显卡 （显示模型）
    /// </summary>
    public class GraphicsView
    {
        public List<GraphicsCard> CardList = new List<GraphicsCard>();
    }

    /// <summary>
    /// 主板
    /// </summary>
    public class BaseBoard
    {
        /// <summary>
        /// 产品名
        /// </summary>
        public string Product { get; set; }

        /// <summary>
        /// 制造商的名称
        /// </summary>
        public string Manufacturer { get; set; }

        /// <summary>
        /// 序列号
        /// </summary>
        public string SerialNumber { get; set; }
        /// <summary>
        /// SKU
        /// </summary>
        public string SKU { get; set; }
        /// <summary>
        /// 描述
        /// </summary>
        public string Description { get; set; }
        /// <summary>
        /// 状态
        /// </summary>
        public string Status { get; set; }
    }

    /// <summary>
    ///计算机产品信息
    /// </summary>
    public class ComputerProductInfo
    {
        /// <summary>
        /// 简短描述
        /// </summary>
        public string Caption { get; set; }
        /// <summary>
        /// 描述
        /// </summary>
        public string Description { get; set; }
        /// <summary>
        /// 产品标识
        /// </summary>
        public string IdentifyingNumber { get; set; }
        /// <summary>
        /// 名称
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// SKU编号
        /// </summary>
        public string SKU { get; set; }
        /// <summary>
        /// 供应商
        /// </summary>
        public string Vendor { get; set; }
        /// <summary>
        /// 产品版本
        /// </summary>
        public string Version { get; set; }
        /// <summary>
        /// UUID
        /// </summary>
        public string UUID { get; set; }

    }
    /// <summary>
    /// CPU信息
    /// </summary>
    public class CPUInfo
    {
        /// <summary>
        /// 所使用的平台的处理器架构
        /// </summary>
        public string Architecture { get; set; }
        /// <summary>
        /// 简短描述
        /// </summary>
        public string Caption { get; set; }
        /// <summary>
        /// 当前状态
        /// </summary>
        public string CpuStatus { get; set; }
        /// <summary>
        /// 处理器的当前速度，以MHz为单位
        /// </summary>
        public string CurrentClockSpeed { get; set; }
        /// <summary>
        /// 在32位处理器，该值是32，在64位处理器是64
        /// </summary>
        public string DataWidth { get; set; }
        /// <summary>
        /// 描述
        /// </summary>
        public string Description { get; set; }
        /// <summary>
        /// 外部时钟频率，以MHz为单位
        /// </summary>
        public string ExtClock { get; set; }
        /// <summary>
        /// 处理器系列类型
        /// </summary>
        public string Family { get; set; }
        /// <summary>
        /// 二级缓存大小 单位（Kb 千字节）
        /// </summary>
        public string L2CacheSize { get; set; }
        /// <summary>
        /// 二级缓存处理器的时钟速度
        /// </summary>
        public string L2CacheSpeed { get; set; }
        /// <summary>
        /// 三级缓存的大小 单位（Kb 千字节）
        /// </summary>
        public string L3CacheSize { get; set; }
        /// <summary>
        /// 三级缓存处理器的时钟速度
        /// </summary>
        public string L3CacheSpeed { get; set; }
        /// <summary>
        /// 处理器的制造商
        /// </summary>
        public string Manufacturer { get; set; }
        /// <summary>
        /// 处理器的最大速度，以MHz为单位
        /// </summary>
        public string MaxClockSpeed { get; set; }
        /// <summary>
        /// 处理器的名称
        /// </summary>
        public string Name { get; set; }

        public string NumberOfCores { get; set; }
        /// <summary>
        /// 每个处理器插槽启用的内核数
        /// </summary>
        public string NumberOfEnabledCore { get; set; }
        /// <summary>
        /// 用于处理器的当前实例逻辑处理器的数量
        /// </summary>
        public string NumberOfLogicalProcessors { get; set; }
        /// <summary>
        /// 处理器系列类型
        /// </summary>
        public string OtherFamilyDescription { get; set; }
        /// <summary>
        /// 处理器的序列号
        /// </summary>
        public string SerialNumber { get; set; }
        /// <summary>
        /// 对象的当前状态
        /// </summary>
        public string Status { get; set; }
        /// <summary>
        /// 系统的名称
        /// </summary>
        public string SystemName { get; set; }
        /// <summary>
        /// UniqueId 全局唯一标识符的处理器
        /// </summary>
        public string UniqueId { get; set; }
        /// <summary>
        /// 依赖于架构处理器的版本号
        /// </summary>
        public string Version { get; set; }
        /// <summary>
        /// 如果真，固件可以虚拟化扩展
        /// </summary>
        public string VirtualizationFirmwareEnabled { get; set; }
        /// <summary>
        /// 如果为True，该处理器支持Intel或AMD虚拟机监控器扩展
        /// </summary>
        public string VMMonitorModeExtensions { get; set; }

    }

    //Computer类
    /// <summary>
    /// 电脑信息类 单例
    /// </summary>
    public class Computer
    {
        private static Computer _instance;
        private static readonly object _lock = new object();
        private Computer()
        { }
        public static Computer CreateComputer()
        {
            if (_instance == null)
            {
                lock (_lock)
                {
                    if (_instance == null)
                    {
                        _instance = new Computer();
                    }
                }
            }
            return _instance;
        }
        /// <summary>
        /// 查找cpu的名称，主频
        /// </summary>
        /// <returns></returns>
        public Tuple<string, string> GetCPU()
        {
            Tuple<string, string> result = null;
            try
            {
                string str = string.Empty;
                ManagementClass mcCPU = new ManagementClass(WindowsAPIType.Win32_Processor.ToString());
                ManagementObjectCollection mocCPU = mcCPU.GetInstances();
                foreach (ManagementObject m in mocCPU)
                {
                    string name = m[WindowsAPIKeys.Name.ToString()].ToString();
                    string[] parts = name.Split('@');
                    result = new Tuple<string, string>(parts[0].Split('-')[0] + "处理器", parts[1]);
                    break;
                }

            }
            catch
            {

            }
            return result;
        }


        /// <summary>
        /// 获取cpu核心数
        /// </summary>
        /// <returns></returns>
        public string GetCPU_Count()
        {
            string str = "查询失败";
            try
            {
                int coreCount = 0;
                foreach (var item in new System.Management.ManagementObjectSearcher("Select * from " +
 WindowsAPIType.Win32_Processor.ToString()).Get())
                {
                    coreCount += int.Parse(item[WindowsAPIKeys.NumberOfCores.ToString()].ToString());
                }
                if (coreCount == 2)
                {
                    return "双核";
                }
                str = coreCount.ToString() + "核";
            }
            catch
            {

            }
            return str;
        }

        /// <summary>
        /// 获取系统内存大小
        /// </summary>
        /// <returns>内存大小（单位M）</returns>
        public string GetPhisicalMemory()
        {
            ManagementObjectSearcher searcher = new ManagementObjectSearcher();   //用于查询一些如系统信息的管理对象 
            searcher.Query = new SelectQuery(WindowsAPIType.Win32_PhysicalMemory.ToString(), "",
new string[] { WindowsAPIKeys.Capacity.ToString() });//设置查询条件 
            ManagementObjectCollection collection = searcher.Get();   //获取内存容量 
            ManagementObjectCollection.ManagementObjectEnumerator em = collection.GetEnumerator();

            long capacity = 0;
            while (em.MoveNext())
            {
                ManagementBaseObject baseObj = em.Current;
                if (baseObj.Properties[WindowsAPIKeys.Capacity.ToString()].Value != null)
                {
                    try
                    {
                        capacity += long.Parse(baseObj.Properties[WindowsAPIKeys.Capacity.ToString()].Value.ToString());
                    }
                    catch
                    {
                        return "查询失败";
                    }
                }
            }
            return CommonUtlity.ToGB((double)capacity, 1024.0);
        }
        /// <summary>
        /// 获取内存信息（显示模型）
        /// </summary>
        /// <returns></returns>
        public MemoryView GetPhisicalMemoryInfo()
        {
            MemoryView view = new MemoryView();
            ManagementClass m = new ManagementClass("Win32_PhysicalMemory");

            ManagementObjectCollection coll = m.GetInstances();

            List<MemoryCardInfo> cardList = new List<MemoryCardInfo>();
            long totalCapacity = 0;
            foreach (var item in coll)
            {
                MemoryCardInfo card = new MemoryCardInfo();
                card.Capacity = item["Capacity"].ToString();
                card.Manufacturer = item["Manufacturer"].ToString();
                card.PartNumber = item["PartNumber"].ToString();
                card.SerialNumber = item["SerialNumber"].ToString();
                card.Voltage = int.Parse(item["ConfiguredVoltage"].ToString());
                card.ConfiguredClockSpeed = int.Parse(item["ConfiguredClockSpeed"].ToString());
                card.DataWidth = int.Parse(item["DataWidth"].ToString());


                cardList.Add(card);
                totalCapacity += long.Parse(card.Capacity);
            }

            view.TotalSize = CommonUtlity.ToGB(totalCapacity, 1024);
            view.MemoryCardList = cardList;
            view.MemoryCount = byte.Parse(cardList.Count().ToString());
            return view;

            ///Win32_PhysicalMemory 内存条 参数说明

            // uint64 Capacity --获取内存容量（单位KB）
            //string Caption  --物理内存还虚拟内存
            //uint32 ConfiguredClockSpeed --配置时钟速度
            //uint32 ConfiguredVoltage  --配置电压
            //string CreationClassName  --创建类名（就是更换这个类的名字）
            //uint16 DataWidth  --获取内存带宽
            //string Description --描述更Caption一样
            //string DeviceLocator --获取设备定位器
            //uint16 FormFactor  --构成因素
            //boolean HotSwappable --是否支持热插拔
            //datetime InstallDate --安装日期（无值）
            //uint16 InterleaveDataDepth --数据交错深度
            //uint32 InterleavePosition  --交错的位置
            //string Manufacturer  --生产商
            //uint32 MaxVoltage --最大电压
            //uint16 MemoryType --内存类型
            //uint32 MinVoltage --最小电压
            //string Model --型号
            //string Name --名字
            //string OtherIdentifyingInfo --其他识别信息
            //string PartNumber --零件编号
            //uint32 PositionInRow --行位置
            //boolean PoweredOn --是否接通电源
            //boolean Removable --是否可拆卸
            //boolean Replaceable --是否可更换
            //string SerialNumber --编号
            //string SKU --SKU号
            //uint32 SMBIOSMemoryType --SMBIOS内存类型
            //uint32 Speed --速率
            //string Status --状态
            //string Tag --唯一标识符的物理存储器
            //uint16 TotalWidth --总宽
            //uint16 TypeDetail --类型详细信息
            //string Version --版本信息

        }
        /// <summary>
        /// 获取磁盘信息
        /// </summary>
        /// <returns></returns>
        public DiskView GetDiskInfo()
        {
            DiskView dv = new DiskView();

            #region 物理磁盘
            ManagementClass m = new ManagementClass("Win32_DiskDrive");

            ManagementObjectCollection coll = m.GetInstances();
            PhisicalDisk pd = new PhisicalDisk();

            foreach (var item in coll)
            {
                pd.Name = item["Name"].ToString();
                pd.Model = item["Model"].ToString();
                pd.Size = UInt64.Parse(item["Size"].ToString());
                pd.Manufacturer = item["Manufacturer"].ToString();
                pd.SerialNumber = item["SerialNumber"].ToString();
                pd.InterfaceType = item["InterfaceType"].ToString();
            }
            dv.PhisicalDiskInfo = pd;
            #endregion

            #region 逻辑磁盘
            ManagementClass mc = new ManagementClass("Win32_LogicalDisk");
            ManagementObjectCollection logic_coll = mc.GetInstances();
            List<LogicalDisk> logicDiskList = new List<LogicalDisk>();
            foreach (var item in logic_coll)
            {
                LogicalDisk ld = new LogicalDisk();
                ld.DeviceID = item["DeviceID"].ToString();
                ld.VolumeName = item["VolumeName"].ToString();
                ld.Size = item["Size"].ToString();
                ld.FreeSpace = UInt64.Parse(item["FreeSpace"].ToString());
                ld.FileSystem = item["FileSystem"].ToString();
                ld.UseSpace = (UInt64.Parse(ld.Size) - ld.FreeSpace).ToString();

                logicDiskList.Add(ld);
            }
            dv.LogicalDiskListInfo = logicDiskList;
            #endregion


            return dv;

            //Win32_DiskDrive 硬盘 参数说明
            //Availability--设备的状态。
            //BytesPerSector--在每个扇区的物理磁盘驱动器的字节数。
            //Capabilities--媒体访问设备的能力阵列。
            //CapabilityDescriptions--更详细的解释为任何在功能阵列表示的访问设备的功能的列表
            //Caption  --对象的序列号
            //CompressionMethod--设备所使用的算法或工具，以支持压缩。
            //ConfigManagerErrorCode--Windows配置管理器错误代码。
            //ConfigManagerUserConfig--如果为True，该设备使用用户定义的配置。
            //CreationClassName--代表所在的类
            //DefaultBlockSize  --此设备默认块大小，以字节为单位。
            //Description--描述
            //DeviceID  --磁盘驱动器与系统中的其他设备的唯一标识符
            //ErrorCleared--如果为True，报告LastErrorCode错误现已清除。
            //ErrorDescription--关于可能采取的纠正措施记录在LastErrorCode错误，和信息的详细信息。
            //ErrorMethodology--误差检测和校正的类型被此设备支持。
            //FirmwareRevision--修订制造商分配的磁盘驱动器固件。
            //Index--给定的驱动器的物理驱动器号。此属性由GetDriveMapInfo方法填补。 0xFF的值表示给定的驱动器不映射到物理驱动器。
            //InstallDate--日期和时间对象安装。此属性不需要的值以表示已安装的对象。
            //InterfaceType--物理磁盘驱动器的类型 （IDE、sata）
            //LastErrorCode--报告的逻辑设备上一个错误代码。
            //Manufacturer--制造商名称
            //MaxBlockSize  --最大块的大小，以字节为单位，通过该设备访问的媒体。
            //MaxMediaSize--最大介质尺寸的介质，以KB为单位，由该设备支持。
            //MediaLoaded--如果真，媒体为一磁盘驱动器加载，这意味着该设备具有一个可读的文件系统和可访问。对于固定磁盘驱动器，该属性将始终为TRUE。
            //MediaType--由该设备使用或访问的媒体类型。
            //MinBlockSize--最小的块大小，以字节为单位，通过该设备访问的媒体。
            //Model--磁盘驱动器的制造商的型号。
            //Name--名字
            //NeedsCleaning  --如果真，媒体接入设备需要清洁。不论手动或自动清洗是可能显示在Capabilities属性。
            //NumberOfMediaSupported--可被支持的或插入的介质最大数量
            //Partitions  --此物理磁盘驱动器上的分区是由操作系统识别的数目。
            //PNPDeviceID--即插即用逻辑设备的播放设备标识符。
            //PowerManagementCapabilities--逻辑设备的特定功率相关的能力阵列。
            //PowerManagementSupported--如果为True，该设备可以是电源管理
            //SCSIBus  --盘驱动器的SCSI总线号。
            //SCSILogicalUnit--SCSI逻辑单元的磁盘驱动器的号码（LUN）。
            //SCSIPort--盘驱动器的SCSI端口号。
            //SCSITargetId--SCSI标识符号码的磁盘驱动器的。
            //SectorsPerTrack--在每个轨道此物理磁盘驱动器扇区数。
            //SerialNumber--由制造商分配的号来识别物理介质。
            //Signature--磁盘识别。该属性可以被用于识别一个共享资源。
            //Size--磁盘大小
            //Status  --对象的当前状态。
            //StatusInfo--逻辑设备的状态
            //SystemCreationClassName  --该作用域计算机的CreationClassName属性的值。
            //SystemName--系统名称
            //TotalCylinders  --物理磁盘驱动器上柱面总数。该值可能不准确
            //TotalHeads  --磁盘驱动器上磁头总数。该值可能不准确。
            //TotalSectors--物理磁盘驱动器上的扇区总数。该值可能不准确。
            //TotalTracks--物理磁盘驱动器上的曲目总数。该值可能不准确。
            //TracksPerCylinder--在物理磁盘驱动器上的每个柱面轨迹的数量。该值可能不准确。
        }

        /// <summary>
        /// 获取硬盘容量
        /// </summary>
        public string GetDiskSize()
        {
            string result = string.Empty;
            StringBuilder sb = new StringBuilder();
            try
            {
                string hdId = string.Empty;
                ManagementClass hardDisk = new ManagementClass(WindowsAPIType.win32_DiskDrive.ToString());
                ManagementObjectCollection hardDiskC = hardDisk.GetInstances();
                foreach (ManagementObject m in hardDiskC)
                {
                    long capacity = Convert.ToInt64(m[WindowsAPIKeys.Size.ToString()].ToString());
                    sb.Append(CommonUtlity.ToGB(capacity, 1000.0) + "+");
                }
                result = sb.ToString().TrimEnd('+');
            }
            catch
            {

            }
            return result;
        }


        ///// <summary>
        ///// 获取硬盘容量
        ///// </summary>
        //public string GetDiskSize()
        //{
        //    string result = string.Empty;
        //    StringBuilder sb = new StringBuilder();
        //    try
        //    {
        //        string hdId = string.Empty;
        //        ManagementClass hardDisk = new ManagementClass(WindowsAPIType.win32_DiskDrive.ToString());
        //        ManagementObjectCollection hardDiskC = hardDisk.GetInstances();
        //        foreach (ManagementObject m in hardDiskC)
        //        {
        //            long capacity = Convert.ToInt64(m[WindowsAPIKeys.Size.ToString()].ToString());
        //            sb.Append(CommonUtlity.ToGB(capacity, 1000.0) + "+");
        //        }
        //        result = sb.ToString().TrimEnd('+');
        //    }
        //    catch
        //    {

        //    }
        //    return result;
        //}

        public Tuple<string, string> GetVideoController()
        {
            Tuple<string, string> result = null;
            try
            {

                ManagementClass hardDisk = new ManagementClass(WindowsAPIType.Win32_VideoController.ToString());
                ManagementObjectCollection hardDiskC = hardDisk.GetInstances();
                foreach (ManagementObject m in hardDiskC)
                {
                    result = new Tuple<string, string>(m[WindowsAPIKeys.VideoProcessor.ToString()].ToString()
.Replace("Family", ""), CommonUtlity.ToGB(Convert.ToInt64(m[WindowsAPIKeys.AdapterRAM.ToString()].ToString()), 1024.0));
                    break;
                }
            }
            catch
            {

            }
            return result;
        }
        /// <summary>
        /// 获取显卡信息 （显示模型）
        /// </summary>
        /// <returns></returns>
        public GraphicsView GetGraphicsInfo()
        {
            GraphicsView gv = new GraphicsView();
            List<GraphicsCard> cardList = new List<GraphicsCard>();

            ManagementClass mc = new ManagementClass(WindowsAPIType.Win32_VideoController.ToString());
            ManagementObjectCollection graphicsColl = mc.GetInstances();

            foreach (var item in graphicsColl)
            {
                GraphicsCard card = new GraphicsCard();
                card.AdapterDACType = item["AdapterDACType"] == null ? "" : item["AdapterDACType"].ToString();
                card.AdapterRAM = UInt32.Parse(item["AdapterRAM"] == null ? "0" : item["AdapterRAM"].ToString());
                card.Caption = item["Caption"] == null ? "" : item["Caption"].ToString();
                card.Description = item["Description"] == null ? "" : item["Description"].ToString();
                card.DriverDate = item["DriverDate"] == null ? "" : item["DriverDate"].ToString();

                card.DriverVersion = item["DriverVersion"] == null ? "" : item["DriverVersion"].ToString();
                card.Name = item["Name"] == null ? "" : item["Name"].ToString();
                card.Status = item["Status"] == null ? "" : item["Status"].ToString();
                card.VideoModeDescription = item["VideoModeDescription"] == null ? "" : item["VideoModeDescription"].ToString();
                card.VideoProcessor = item["VideoProcessor"] == null ? "" : item["VideoProcessor"].ToString();

                card.MaxRefreshRate = item["MaxRefreshRate"] == null ? 0 : UInt32.Parse(item["MaxRefreshRate"].ToString());
                card.MinRefreshRate = item["MinRefreshRate"] == null ? 0 : UInt32.Parse(item["MinRefreshRate"].ToString());
                card.CurrentBitsPerPixel = item["CurrentBitsPerPixel"] == null ? 0 : UInt32.Parse(item["CurrentBitsPerPixel"].ToString());

                cardList.Add(card);
            }


            gv.CardList = cardList;
            return gv;


            //Win32_VideoController 获取电脑硬件信息参数说明

            //AcceleratorCapabilities--图形和视频控制器的三维阵列的能力
            //AdapterCompatibility  --用于此控制器与系统比较兼容性一般芯片组
            //AdapterDACType--姓名或数字 - 模拟转换器（DAC）芯片的标识符
            //AdapterRAM  --视频适配器的内存大小
            //Availability--可用性和设备的状态
            //CapabilityDescriptions  --自由形式字符串提供更详细的解释中的任何加速器能力阵列所指示的视频加速器功能
            //Caption--对象的简短描述
            //ColorTableEntries  --尺寸系统的色表
            //ConfigManagerErrorCode--Win32的配置管理器错误代码
            //ConfigManagerUserConfig  --如果为TRUE，该装置是使用用户定义的配置
            //CreationClassName  --第一个具体类的名称出现在创建实例所使用的继承链
            //CurrentBitsPerPixel--使用的比特数以显示每个像素
            //CurrentHorizontalResolution  --水平像素的当前数量
            //CurrentNumberOfColors--在当前的分辨率支持的色彩数目
            //CurrentNumberOfColumns  --此视频控制器列（如果在字符模式下）编号
            //CurrentNumberOfRows  --此视频控制器行（如果在字符模式下）编号
            //CurrentRefreshRate  --频率在该视频控制器刷新监视器的图像
            //CurrentScanMode--当前扫描模式
            //CurrentVerticalResolution  --当前垂直像素数量
            //Description--描述
            //DeviceID  --该视频控制器标识符（唯一的计算机系统）
            //DeviceSpecificPens--目前许多设备专用笔。值0xFFFF表示设备不支持笔。
            //DitherType--抖动型视频控制器
            //DriverDate  --当前已安装的视频驱动程序的最后修改日期和时间
            //DriverVersion--视频驱动程序的版本号
            //ErrorCleared  --如果为真，报上一个错误代码属性中的错误现已清除
            //ErrorDescription  --可能采取的纠正措施字符串提供有关记录在一个错误代码属性错误的详细信息
            //ICMIntent--应使用默认三种可能的配色方法或意图中的一个特定值
            //ICMMethod  --处理ICM方法。对于非ICM的应用程序，这个属性决定了ICM是否已启用对于ICM的应用程序，系统将检查此属性来确定如何处理ICM支持
            //InfFilename  --视频适配器的路径.inf文件
            //InfSection--Windows的视频信息所在的.inf文件
            //InstallDate  --安装的日期
            //InstalledDisplayDrivers--已安装的显示设备驱动程序的名称
            //LastErrorCode  --报告的逻辑设备上一个错误代码
            //MaxMemorySupported--以字节为单位支持的内存最高限额
            //MaxNumberControlled  --可支持通过该控制器可直接寻址的实体的最大数量
            //MaxRefreshRate--在赫兹视频控制器的最大刷新率
            //MinRefreshRate   --在赫兹视频控制器的最小刷新率
            //Monochrome--如果是TRUE，灰阶用于显示图像。
            //Name--标签由该对象是已知的。当子类，该属性可以被覆盖是一个关键属性。
            //NumberOfColorPlanes--当前一些颜色平面。如果该值不适用于当前视频的配置，输入0（零）
            //NumberOfVideoPages--当前的分辨率和可用内存支持视频页数
            //PNPDeviceID  --即插即用逻辑设备的播放装置识别符
            //PowerManagementCapabilities--逻辑设备的特定功率相关的能力阵列
            //PowerManagementSupported  --如果为TRUE，该装置可以是电源管理（可以投入挂起模式，等等）
            //ProtocolSupported--由控制器使用协议访问“控制”的设备
            //ReservedSystemPaletteEntries  --系统调色板保留的条目数
            //SpecificationVersion--初始化数据规范的版本号（在其上的结构的基础）
            //Status--对象的当前状态
            //StatusInfo  --对象的当前状态详细信息
            //SystemCreationClassName--该作用域计算机的创建类别名称属性的值
            //SystemName  --系统的名称
            //SystemPaletteEntries--当前一些系统调色板颜色索引条目
            //TimeOfLastReset  --该控制器是最后一次复位日期和时间，这可能意味着该控制器被断电或重新初始化
            //VideoArchitecture  --视频体系结构的类型
            //VideoMemoryType--显存类型
            //VideoMode  --当前视频模式
            //VideoModeDescription--当前的分辨率，颜色和视频控制器的扫描模式设置
            //VideoProcessor  --无格式的字符串描述视频处理器

        }

        /// <summary>
        /// 获取主板信息
        /// </summary>
        /// <returns></returns>
        public BaseBoard GetBaseBoard()
        {
            BaseBoard bb = new BaseBoard();
            ManagementClass mc = new ManagementClass("Win32_BaseBoard");
            ManagementObjectCollection bbColl = mc.GetInstances();
            foreach (var item in bbColl)
            {
                bb.Description = item["Description"] + "";
                bb.Manufacturer = item["Manufacturer"] + "";
                bb.Product = item["Product"] + "";
                bb.SerialNumber = item["SerialNumber"] + "";
                bb.SKU = item["SKU"] + "";
                bb.Status = item["Status"] + "";
            }
            return bb;

        }

        /// <summary>
        /// 获取计算机产品信息
        /// </summary>
        /// <returns></returns>
        public ComputerProductInfo GetComputerProductInfo()
        {
            ComputerProductInfo cp = new ComputerProductInfo();

            ManagementClass mc = new ManagementClass("Win32_ComputerSystemProduct");
            ManagementObjectCollection cpColl = mc.GetInstances();
            foreach (var item in cpColl)
            {
                cp.Description = item["Description"] + "";
                cp.Caption = item["Caption"] + "";
                cp.IdentifyingNumber = item["IdentifyingNumber"] + "";
                cp.Name = item["Name"] + "";
                cp.SKU = item["SKUNumber"] + "";
                cp.UUID = item["UUID"] + "";

                cp.Vendor = item["Vendor"] + "";
                cp.Version = item["Version"] + "";

            }

            return cp;

        }

        public CPUInfo GetCPUInfo()
        {
            CPUInfo ci = new CPUInfo();

            ManagementClass mc = new ManagementClass("Win32_Processor");
            ManagementObjectCollection ciColl = mc.GetInstances();
            foreach (var item in ciColl)
            {
                ci.Architecture = item["Architecture"] + "";
                ci.Caption = item["Caption"] + "";
                ci.CpuStatus = item["CpuStatus"] + "";
                ci.CurrentClockSpeed = item["CurrentClockSpeed"] + "";
                ci.DataWidth = item["DataWidth"] + "";
                ci.Description = item["Description"] + "";

                ci.ExtClock = item["ExtClock"] + "";
                ci.Family = item["Family"] + "";

                ci.L2CacheSize = item["L2CacheSize"] + "";
                ci.L2CacheSpeed = item["L2CacheSpeed"] + "";
                ci.L3CacheSize = item["L3CacheSize"] + "";
                ci.L3CacheSpeed = item["L3CacheSpeed"] + "";
                ci.Manufacturer = item["Manufacturer"] + "";
                ci.MaxClockSpeed = item["MaxClockSpeed"] + "";

                ci.Name = item["Name"] + "";
                ci.NumberOfCores = item["NumberOfCores"] + "";
                ci.NumberOfEnabledCore = item["NumberOfEnabledCore"] + "";
                ci.NumberOfLogicalProcessors = item["NumberOfLogicalProcessors"] + "";
                ci.OtherFamilyDescription = item["OtherFamilyDescription"] + "";
                ci.SerialNumber = item["SerialNumber"] + "";
                ci.Status = item["Status"] + "";
                ci.SystemName = item["SystemName"] + "";
                ci.UniqueId = item["UniqueId"] + "";
                ci.Version = item["Version"] + "";
                ci.VirtualizationFirmwareEnabled = item["VirtualizationFirmwareEnabled"] + "";
                ci.VMMonitorModeExtensions = item["VMMonitorModeExtensions"] + "";
            }

            return ci;
        }

        /// <summary>
        /// 电脑型号
        /// </summary>
        public string GetVersion()
        {
            string str = "查询失败";
            try
            {
                string hdId = string.Empty;
                ManagementClass hardDisk = new ManagementClass(WindowsAPIType.Win32_ComputerSystemProduct.ToString());
                ManagementObjectCollection hardDiskC = hardDisk.GetInstances();
                foreach (ManagementObject m in hardDiskC)
                {
                    str = m[WindowsAPIKeys.Version.ToString()].ToString(); break;
                }
            }
            catch
            {

            }
            return str;
        }
        /// <summary>
        /// 获取分辨率
        /// </summary>
        public string GetFenbianlv()
        {
            string result = "1920*1080";
            try
            {
                string hdId = string.Empty;
                ManagementClass hardDisk = new ManagementClass(WindowsAPIType.Win32_DesktopMonitor.ToString());
                ManagementObjectCollection hardDiskC = hardDisk.GetInstances();
                foreach (ManagementObject m in hardDiskC)
                {
                    result = m[WindowsAPIKeys.ScreenWidth.ToString()].ToString() + "*" +
m[WindowsAPIKeys.ScreenHeight.ToString()].ToString();
                    break;
                }
            }
            catch
            {

            }
            return result;
        }
        /// <summary>
        /// 显卡 芯片,显存大小
        /// </summary>


        /// <summary>
        /// 操作系统版本
        /// </summary>
        public string GetOS_Version()
        {
            string str = "Windows 10";
            try
            {
                string hdId = string.Empty;
                ManagementClass hardDisk = new ManagementClass(WindowsAPIType.Win32_OperatingSystem.ToString());
                ManagementObjectCollection hardDiskC = hardDisk.GetInstances();
                foreach (ManagementObject m in hardDiskC)
                {
                    str = m[WindowsAPIKeys.Name.ToString()].ToString().Split('|')[0].Replace("Microsoft", "");
                    break;
                }
            }
            catch
            {

            }
            return str;
        }
        /// <summary>
        /// 获取用户名
        /// </summary>
        /// <returns></returns>
        public string GetCurrUserName()
        {
            string str = "";
            ManagementClass m = new ManagementClass("Win32_ComputerSystem");
            ManagementObjectCollection coll = m.GetInstances();
            foreach (ManagementObject item in coll)
            {
                str = item["UserName"] + "";
            }
            return str;
        }

        /// <summary>
        /// 计算机名
        /// </summary>
        /// <returns></returns>
        public string ComputerName()
        {
            return Environment.MachineName;

        }
        /// <summary>
        /// user Domin name
        /// </summary>
        /// <returns></returns>
        public string DominName()
        {
            return Environment.UserDomainName;
        }
        /// <summary>
        /// 当前用户名
        /// </summary>
        /// <returns></returns>
        public string CurUserName()
        {
            return Environment.UserName;
        }
        /// <summary>
        /// 多少位操作系统
        /// </summary>
        /// <returns></returns>
        public string OperationSystemBit()
        {

            return Environment.Is64BitOperatingSystem ? "64位" : "32位";
        }

        /// <summary>
        /// 平台标识符、版本
        /// </summary>
        /// <returns></returns>
        public string OSVersionStr()
        {

            return Environment.OSVersion.VersionString;
        }
        /// <summary>
        /// 系统目录
        /// </summary>
        /// <returns></returns>
        public string SystemDirectory()
        {

            return Environment.SystemDirectory;
        }

    }



}
